
# Importacion.
from scipy.io import wavfile
import IPython
import os
import numpy as np
import matplotlib.pyplot as plt

# Directorios que usaremos.
cwd = os.getcwd()
audio_input_path = os.path.join(cwd, os.path.join('audio', '_input'))  # audio_examples
audio_output_path = os.path.join(cwd, os.path.join('audio', '_output'))
print(f'Path to input audio: {audio_input_path}')
print(f'Path to output audio: {audio_output_path}\n')

Path to input audio: /home/sfandres/Documents/Git/uex-audiopy/audio/_input
Path to output audio: /home/sfandres/Documents/Git/uex-audiopy/audio/_output


# # Input data.
# filename = os.path.join('audio/input', 'salpique.wav')
# sample_rate_v0, audio_data_v0 = wavfile.read(filename)
# print(f'Shape of the input audio data: {audio_data_v0.shape}\n')

# # Slicing with stride (stereo).
# new_data_v0 = audio_data_v0[1500000//2:1500000*2, :]

# # Writing to a wav file.
# wavfile.write(
#     filename=os.path.join('audio', 'salpique_min_stereo.wav'),
#     rate=sample_rate_v0,
#     data=new_data_v0
# )

# # Loading the new audio data.
# filename = os.path.join('audio', 'salpique_min_stereo.wav')
# sample_rate_v1, audio_data_v1 = wavfile.read(filename)
# print(f'Shape of the input audio data min: {audio_data_v1.shape}')
# print(f'Reduction (%): {int((len(audio_data_v0)-len(audio_data_v1))*100/len(audio_data_v0))}')


# IPython.display.Audio(audio_data_v1.T, rate=sample_rate_v1)


# Cargamos el archivo de audio.
filename = os.path.join(audio_input_path, 'sample1_stereo.wav')
sample_rate, audio_data = wavfile.read(filename)
print(f'Frecuencia de muestreo (sample rate): {sample_rate/1000} kHz')

Frecuencia de muestreo (sample rate): 44.1 kHz


IPython.display.Audio(audio_data.T, rate=sample_rate) # .T se pasa únicamente si es audio estéreo.


# Mostrar informacion (sonido estéreo).
print('Datos de audio (estereo):')
print(f'- Tamaño:     {audio_data.shape}')
print(f'- 1º canal:   {audio_data[:5, 0]}...')
print(f'- 2º canal:   {audio_data[:5, 1]}...')
print(f'- Resolucion: {type(audio_data[0,0])}\n')

Datos de audio (estereo):
- Tamaño:     (5384326, 2)
- 1º canal:   [137 140  91   4 -69]...
- 2º canal:   [ 66  38   0 -10  45]...
- Resolucion: <class 'numpy.int16'>


# Convertimos a mono mediante la media por canal (simplificacion).
new_data_mono = audio_data.mean(axis=1)  # Column-wise.
print('Nuevos datos de audio (mono):')
print(f'- Nuevo tamaño: {new_data_mono.shape}')
print(f'- Canal unico:  {new_data_mono[:5]}...')

# Mantenemos la misma resolucion que antes.
new_data_mono = new_data_mono.astype(np.int16)
print(f'- Resolucion:   {type(new_data_mono[0])}\n')

Nuevos datos de audio (mono):
- Nuevo tamaño: (5384326,)
- Canal unico:  [101.5  89.   45.5  -3.  -12. ]...
- Resolucion:   <class 'numpy.int16'>


# Guardamos el archivo mono a un fichero de tipo wav.
wavfile.write(
    filename=os.path.join(audio_output_path, 'sample1_mono.wav'),
    rate=sample_rate,
    data=new_data_mono
)


IPython.display.Audio(new_data_mono, rate=sample_rate)


!ls -sh audio/_input/sample1_stereo.wav
!ls -sh audio/_output/sample1_mono.wav

21M audio/_input/sample1_stereo.wav
11M audio/_output/sample1_mono.wav


print(f'Frecuencia de muestreo (sample rate): {sample_rate/1000} kHz\n')

Frecuencia de muestreo (sample rate): 44.1 kHz


# Cargamos los archivos de audio.
sample_rate_48, audio_data_48 = wavfile.read(filename=os.path.join(audio_input_path, 'sample_48kHz.wav'))
sample_rate_24, audio_data_24 = wavfile.read(filename=os.path.join(audio_input_path, 'sample_24kHz.wav'))

# Otro ejemplo sería: audio_data, sample_rate = librosa.load(filename)

print(f'{audio_data_48.shape}\n')  # Audio mono
print(f'{audio_data_24.shape}\n')  # Audio mono

(176542,)

(88271,)


IPython.display.Audio(audio_data_48, rate=sample_rate_48)


IPython.display.Audio(audio_data_24, rate=sample_rate_24)


!ls -sh audio/_input/sample_48kHz.wav
!ls -sh audio/_input/sample_24kHz.wav

348K audio/_input/sample_48kHz.wav
176K audio/_input/sample_24kHz.wav


ampl_values_48 = len(audio_data_48)
print(f'Número de muestras del archivo (valores de amplitud): {ampl_values_48}')

Número de muestras del archivo (valores de amplitud): 176542


ampl_values_24 = len(audio_data_24)
print(f'Número de muestras del archivo (valores de amplitud): {ampl_values_24}')

Número de muestras del archivo (valores de amplitud): 88271


# Valor inicial: 0
# Valor final: muestras/frecuencia de muestreo
# Incremento: 1/frecuencia de muestreo
t1 = np.arange(0, ampl_values_48/sample_rate_48, 1/sample_rate_48)
t2 = np.arange(0, ampl_values_24/sample_rate_24, 1/sample_rate_24)

# Mostrar gráfica.
fig, ax = plt.subplots(2, 1, figsize=(12, 6), sharex=True)
ratio = sample_rate_48 / sample_rate_24
end = 50

ax[0].plot(t1[:end], audio_data_48[:end])
ax[0].set_title(f'Audio en el dominio del tiempo muestreado a {sample_rate_48} Hz')
ax[0].set_ylabel('Amplitud')
ax[0].grid(True)

ax[1].plot(t2[:int(end/ratio)], audio_data_24[:int(end/ratio)], c='tab:red')
ax[1].set_title(f'Audio en el dominio del tiempo muestreado a {sample_rate_24} Hz')
ax[1].set_xlabel('Tiempo (s)')
ax[1].set_ylabel('Amplitud')
ax[1].grid(True)

plt.tight_layout()
plt.show()


# La longitud del array de datos y el
# sample rate (frecuencia de muestreo).
n = len(audio_data_48)
Fs = sample_rate_48

# Working with stereo audio, there are two channels in the audio data.
# Let's retrieve each channel seperately:
# ch1 = np.array([data[i][0] for i in range(n)]) #channel 1
# ch2 = np.array([data[i][1] for i in range(n)]) #channel 2
# We can then perform a Fourier analysis on the first
# channel to see what the spectrum looks like.

# Calculando la Transformada Rapida de Fourier (FFT) en audio mono.
ch_Fourier = np.fft.fft(audio_data_48)  # ch1

# Solo miramos frecuencia por debajo de Fs/2
# (Nyquist-Shannon) --> Spectrum.
abs_ch_Fourier = np.absolute(ch_Fourier[:n//2])

# Graficamos.
plt.plot(np.linspace(0, Fs/2, n//2), abs_ch_Fourier)
plt.ylabel('Amplitud', labelpad=10)
plt.xlabel('$f$ (Hz)', labelpad=10)
plt.show()


# Definimos epsilon: la parte de la energia
# del espectro que no conservamos.
eps = [1e-5, .02, .041, .063, .086, .101, .123]

# Jugamos con los valores de epsilon
eps = eps[0]  # Cambiar.
print(f'Epsilon: {eps}')

# Calculamos el valor de corte para esta energia.
thr_spec_energy = (1 - eps) * np.sum(abs_ch_Fourier)
print(f'Valor de corte para la energia del espectro: {thr_spec_energy}')

# Integral de la frecuencia --> energia del espectro.
spec_energy = np.cumsum(abs_ch_Fourier)

# Mascara (array booleano) que compara el valor
# de corte con la energia del espectro.
frequencies_to_remove = thr_spec_energy < spec_energy  
print(f'Mascara: {frequencies_to_remove}')

# La frecuencia f0 por la que cortamos el espectro.
f0 = (len(frequencies_to_remove) - np.sum(frequencies_to_remove)) * (Fs/2) / (n//2)
print(f'Frecuencia de corte f0 (Hz): {int(f0)}')

# Graficamos.
plt.axvline(f0, color='r')
plt.plot(np.linspace(0, Fs/2, n//2), abs_ch_Fourier)
plt.ylabel('Amplitud')
plt.xlabel('$f$ (Hz)')
plt.show()

Epsilon: 1e-05
Valor de corte para la energia del espectro: 50667270320.0895
Mascara: [False False False ...  True  True  True]
Frecuencia de corte f0 (Hz): 23992


# Definimos los nombres de los audios comprimidos.
wav_compressed_file = "sample_48kHz_compressed.wav"

# Calculamos el factor D de downsampling.
D = int(Fs / f0)
print(f'Factor de downsampling: {D}')

# Obtenemos los nuevos datos (slicing with stride).
new_data = audio_data_48[::D]

# Escribimos los datos a un archivo de tipo wav.
wavfile.write(
    filename=os.path.join(audio_output_path, wav_compressed_file),
    rate=int(Fs/D),
    data=new_data
)

# Cargamos el nuevo archivo.
new_sample_rate, new_audio_data = wavfile.read(filename=os.path.join(audio_output_path, wav_compressed_file))

Factor de downsampling: 2


IPython.display.Audio(new_audio_data, rate=new_sample_rate)


!ls -sh audio/_output/sample_48kHz_compressed.wav

176K audio/_output/sample_48kHz_compressed.wav


fig, ax = plt.subplots(2, 1, figsize=(12, 8), sharex=True)

Pxx, freqs, bins, im = ax[0].specgram(audio_data_48, NFFT=1024, Fs=sample_rate_48, noverlap=512)
ax[0].set_title('Espectograma del audio original')
ax[0].set_ylabel('Frecuencia (Hz)')
ax[0].grid(True)

Pxx, freqs, bins, im = ax[1].specgram(new_audio_data, NFFT=1024, Fs=new_sample_rate, noverlap=512)
ax[1].set_title('Espectrograma del audio reducido/comprimido')
ax[1].set_xlabel('Tiempo (s)')
ax[1].set_ylabel('Frecuencia (Hz)')
ax[1].grid(True)

plt.tight_layout()
plt.show()

Sesión 4 de SM: Introducción al procesamiento de audio con Python¶

Objetivos¶

Importar librerías y módulos de Python¶

Bibliografía consultada¶

Codigo para reducir un archivo de audio truncando (ignorar)¶

Primeros pasos: Cargar el archivo de audio (sonido estéreo vs mono)¶

Teoría: Toma de muestras de audio¶

Definición de muestra¶

Frecuencia de muestreo (sample rate)¶

Definición¶

Valores más comunes de frecuencia de muestreo¶

Pregunta sencilla: a mayor frecuencia de muestreo, ¿mayor calidad?¶

Caso real: ¿A qué valor fijamos la frecuencia de muestreo?¶

Cuando el muestreo sale mal: Aliasing¶

Mas teoría: Características de grabación de audio digital¶

Profundidad de bits (bit depth)¶

Ancho de banda (bandwidth)¶

Suele llevar a confusión: Frecuencia de muestreo vs tasa de bits (bitrate)¶

Práctica: Compresión de audio¶

Cargar audios¶

Gráficas características¶

Dominio del tiempo¶

Dominio de la frecuencia: Transformada de Fourier (FFT)¶

Teoría¶

Análisis de Fourier¶

Energia del espectrograma y frecuencia de corte¶

Compresión del archivo¶

Reducción de la resolución de muestreo (downsampling)¶

Espectrograma¶